#include <cassert>
#include "SDLjeu.h"
#include <SDL/SDL_ttf.h>
#include<cassert>


const int TAILLE_SPRITE=40;
SDL_Surface *SDL_load_image(const char* filename );
void SDL_apply_surface( SDL_Surface* source, SDL_Surface* destination, int x, int y );

SDL_Surface *SDL_load_image(const char* filename )
{
    /**Temporary storage for the image that's loaded*/
    SDL_Surface* loadedImage = NULL;

    /**The optimized image that will be used*/
    SDL_Surface* optimizedImage = NULL;

    /**Load the image*/
    loadedImage = SDL_LoadBMP(filename);

    /**If nothing went wrong in loading the image*/
    if ( loadedImage != NULL )
    {
        /**Create an optimized image*/
        optimizedImage = SDL_DisplayFormat( loadedImage );

        /**Free the old image*/
        SDL_FreeSurface( loadedImage );
    }

    /**Return the optimized image*/
    return optimizedImage;
}


void SDL_apply_surface( SDL_Surface* source, SDL_Surface* destination, int x, int y )
{
    /**Make a temporary rectangle to hold the offsets*/
    SDL_Rect offset;

    /**Give the offsets to the rectangle*/
    offset.x = x;
    offset.y = y;

    /**Blit the surface*/
    SDL_BlitSurface( source, NULL, destination, &offset );
}


void sdljeuInit(sdlJeu& sj)
{
    jeuInit(sj.jeu );
    assert(SDL_Init( SDL_INIT_EVERYTHING )!= -1 );
    int dimx, dimy;
    dimx = getDimX( jeuGetConstPlateau(sj.jeu) );
    dimy = getDimY( jeuGetConstPlateau(sj.jeu) );
    dimx = dimx * TAILLE_SPRITE;
    dimy = dimy * TAILLE_SPRITE;

    sj.ecran = SDL_SetVideoMode(dimx*2, dimy*2, 32, SDL_HWSURFACE | SDL_RESIZABLE |SDL_DOUBLEBUF);
    //640,640
    assert( sj.ecran );

    SDL_WM_SetCaption( "JEU ECHEC.2", NULL );

    sj.plateau = SDL_load_image("data/plateau1.bmp");
    assert( sj.plateau);

    sj.pionN= SDL_load_image("data/pionN.bmp");
    assert( sj.pionN);

    sj.pionB= SDL_load_image("data/pionB.bmp");
    assert( sj.pionB);

    sj.dameN=SDL_load_image("data/dameN.bmp");
    assert(sj.dameN);

    sj.dameB=SDL_load_image("data/dameB.bmp");
    assert(sj.dameB);

    sj.fouN=SDL_load_image("data/fouN.bmp");
    assert(sj.fouN);

    sj.fouB=SDL_load_image("data/fouB.bmp");
    assert(sj.fouB);

    sj.roiN=SDL_load_image("data/roiN.bmp");
    assert(sj.roiN);

    sj.roiB=SDL_load_image("data/roiB.bmp");
    assert(sj.roiB);

    sj.tourN=SDL_load_image("data/tourN.bmp");
    assert(sj.tourN);

    sj.tourB=SDL_load_image("data/tourB.bmp");
    assert(sj.tourB);

    sj.cavalierN=SDL_load_image("data/cavalierN.bmp");
    assert(sj.cavalierN);

    sj.cavalierB=SDL_load_image("data/cavalierB.bmp");
    assert(sj.cavalierB);

}

void sdljeuAff(sdlJeu& sj)
{
    /**Remplir l'écran de blanc*/
    SDL_FillRect( sj.ecran, &sj.ecran->clip_rect, SDL_MapRGB( sj.ecran->format,0xFF, 0xFF, 0xFF ) );
    int x,y;
    int xEcran,yEcran;

    const Plateau& plateau = jeuGetConstPlateau(sj.jeu);
    SDL_apply_surface(  sj.plateau, sj.ecran, 160,160);
                for(xEcran=160;xEcran<480;xEcran=xEcran+40)
                {
                    for(yEcran=160;yEcran<480;yEcran=yEcran+40)
                    {
                    ecranVersPlateau(xEcran,yEcran,x,y);

            switch ( platGetXY(plateau,y,x))
            {
            case TourB:
               SDL_apply_surface(sj.tourB, sj.ecran,xEcran,yEcran);

            break;

            case TourN:
                SDL_apply_surface(sj.tourN, sj.ecran,xEcran,yEcran);
            break;

            case CavalierB:
                SDL_apply_surface(sj.cavalierB, sj.ecran, xEcran,yEcran);
            break;

            case CavalierN:
                SDL_apply_surface(sj.cavalierN, sj.ecran, xEcran,yEcran);
            break;

            case FouB:
                SDL_apply_surface(  sj.fouB, sj.ecran, xEcran,yEcran);
            break;

            case FouN:
                SDL_apply_surface(  sj.fouN, sj.ecran, xEcran,yEcran);
            break;

            case RoiB:
                SDL_apply_surface(  sj.roiB, sj.ecran, xEcran,yEcran);
            break;

            case RoiN:
                SDL_apply_surface(  sj.roiN, sj.ecran, xEcran,yEcran);
            break;

            case DameB:
                SDL_apply_surface(  sj.dameB, sj.ecran,xEcran,yEcran);
            break;

            case DameN:
                SDL_apply_surface(  sj.dameN, sj.ecran, xEcran,yEcran);
            break;

            case PionB:
                SDL_apply_surface(  sj.pionB, sj.ecran, xEcran,yEcran);
            break;

            case PionN:
                SDL_apply_surface(  sj.pionN, sj.ecran, xEcran,yEcran);
            break;

            default:

            break;
            }

        }
    }

}


void sdljeuBoucle(sdlJeu& sj)
{
    SDL_Event event;
    int x1,y1,x2,y2;
    int x3,y3,x4,y4;
    bool p1=0;
    bool p2=0;
    bool ok1;
    bool ok2;
    bool joueur1=true;
    bool joueur2=false;
    const Plateau& plateau = jeuGetConstPlateau(sj.jeu);
    bool matRoiB=false;
    bool matRoiN=false;
    bool quit = false;
    typePiece piece1;
    typePiece piece2;
    typePiece piece3;
    typePiece piece4;

    sdljeuAff( sj );

    assert( SDL_Flip( sj.ecran )!=-1 );
 while ( quit == false && !matRoiB && !matRoiN )
    {
        while ( SDL_PollEvent( &event ) )
        {
            {

            /**LES BLANCS JOUENT*/

            if(joueur1 && !joueur2)
            {
                switch (event.type)
            {
                case  SDL_MOUSEBUTTONUP:

            if (event.button.button == SDL_BUTTON_LEFT && !p1) /**si on fait un clic gauche, premier coup des blancs*/
                {
                    ecranVersPlateau( event.button.x, event.button.y,x1,y1); /** x1 et y1 sont les coordonnées de la piece sur le plateau*/
                    piece1=platGetXY(plateau,y1,x1);
                    if(platEstPositionPieceValide(plateau,x1,y1))
                    if (piece1!=Vide && piece1<7) /**on teste si la case où on a cliqué contient une piece blanche*/
                    {
                        p1=1;
                    }
                }


            if ((event.button.button == SDL_BUTTON_RIGHT) && p1 && !p2) /**on verifie si le clic droit est fait après le clic gauche   */
                {
                    ecranVersPlateau( event.button.x, event.button.y, x2,y2);
                    piece2=platGetXY(plateau,y2,x2);

                    if(platEstPositionPieceValide(plateau,x2,y2))
                    if(piece1!=piece2);
                    {
                        ok1=piecePeutAvancer2(y1,x1,jeuGetPlateau(sj.jeu),y2,x2);
                        if (ok1)
                        {
                        jeuActionClavier(sj.jeu,y1,x1,y2,x2);
                        joueur1=false;
                        joueur2=true;
                        matRoiN=echecEtMatRoiN(jeuGetPlateau(sj.jeu));
                        }
                        else
                        {p1=0;}


                    }
                }
                break;

                case SDL_QUIT: /**Si l'utilisateur a cliqué sur la croix de fermeture*/
                quit=true;
                break;
            } /**ferme le switch blanc*/
        } /**erme le tour des blancs*/

        /**LES NOIRS JOUENT*/

             if(!joueur1 && joueur2)
            {
                switch (event.type)
            {
                case  SDL_MOUSEBUTTONUP:

                if(event.button.button == SDL_BUTTON_LEFT && !p2 && p1)
                {
                    ecranVersPlateau( event.button.x, event.button.y,x3,y3);
                    piece3=platGetXY(plateau,y3,x3);
                  if(platEstPositionPieceValide(plateau,x3,y3))
                    if(piece3!=Vide && piece3>6) /**on s'assure que ce sont les noirs qui jouent*/
                    {
                        p2=1;
                    }
                }


                if ((event.button.button == SDL_BUTTON_RIGHT) && p2 ) /**on verifie si le clic droit est fait après le clic gauche   */
                {
                    ecranVersPlateau( event.button.x, event.button.y, x4,y4);
                    piece4=platGetXY(plateau,y4,x4);

                   if(platEstPositionPieceValide(plateau,x4,y4))
                    if(piece3!=piece4);
                        {
                            ok2=piecePeutAvancer2(y3,x3,jeuGetPlateau(sj.jeu),y4,x4);
                            if (ok2)
                            {
                            jeuActionClavier(sj.jeu,y3,x3,y4,x4);
                            joueur1=true;
                            joueur2=false;
                            p1=0;
                            p2=0;
                            matRoiB=echecEtMatRoiB(jeuGetPlateau(sj.jeu));

                            }
                            else
                            {
                               p2=0;
                            }

                        }
                }
                break;

                case SDL_QUIT: /**Si l'utilisateur a cliqué sur la croix de fermeture*/
                quit=true;
                break;
            }
            }


        }

    }


        sdljeuAff( sj);
        /**on permute les deux buffers (cette fonction ne doit se faire qu'une seule fois dans la boucle)*/
       SDL_Flip( sj.ecran);


    }

}

void sdljeuDetruit( sdlJeu& sj)
{
    SDL_FreeSurface( sj.tourB );
    SDL_FreeSurface( sj.tourN );
    SDL_FreeSurface( sj.cavalierB );
    SDL_FreeSurface( sj.cavalierN );
    SDL_FreeSurface( sj.dameB);
    SDL_FreeSurface( sj.dameN );
    SDL_FreeSurface( sj.fouB );
    SDL_FreeSurface( sj.fouN );
    SDL_FreeSurface( sj.roiB);
    SDL_FreeSurface( sj.roiN );
    SDL_FreeSurface( sj.pionB);
    SDL_FreeSurface( sj.pionN );
    SDL_FreeSurface( sj.plateau );
    SDL_Quit();
}









